package com.ajz;


public class Object {

    int a = 10;

    static  int b = 11;

    public  void  C(){
    	
    }

    public static void main(String[] args) {
        //对对象的进一步的讨论

        test3 t3 = new test3();



        System.out.println(t3.t2.i);

        System.out.println(t3.t2.j);

        //使用对象作为方法参数进行传递

        test4 t4_1 = new test4(200,300);
        test4 t4_2 = new test4(100,300);
        test4 t4_3 = new test4(200,300);

        System.out.println("t4_1 == t4_2:"+t4_1.equals(t4_2));
        System.out.println("t4_1 == t4_3:"+t4_1.equals(t4_3));
        System.out.println("t4_3 == t4_2:"+t4_3.equals(t4_2));

        //使用对象作为方法的返回值
        test5 t5 = new test5(3);

        test5 t5temp = t5.returnBy();

        System.out.println(t5.a);

        System.out.println(t5temp.a);

        t5temp = t5temp.returnBy();

        System.out.println(t5temp.a);

        //内部嵌套类:
        //1.它仅能被他的上一级的类所调用
        //2.外部定义的类不可以访问内部嵌套类

        test6 t6 = new test6();

        System.out.println(t6.t6_qt.a);

        t6.t6_qt.methed_qt();

        //静态内部类
        //1.外部类不需要创建内部类的对象即可调用内部类的变量和方法
        System.out.println(test.j);   //调用内部类的属性

        Object.test obj_t = new Object.test();

        obj_t.getValue();  //调用静态内部类的方法!


        //成员内部类

        test t = new test();

        test6 test6 = new test6();


       

        test1 o = new Object().new test1(2);









    }


    //内部嵌套类:静态内部类
    // 1.可以有非静态的成员,并且可以访问外部的静态成员,但不能访问外部的非静态成员
    static class test{
        int i = 0;

        static int j = 1;

        public void getValue() {

            System.out.println(b); //可以访问外部的静态属性,不能访问外部的非静态属性

        }

    }

    void insets(){

        test1 t1 = new test1(5);

    }

    //内部嵌套类: 非静态内部类-成员内部类 :
    class test1{

       int i ;

       test1(int a){
           i = a;
       }

       public  void  t1_methed(){

           System.out.println("我是成员内部类的方法");

       }

    }
}

//内部嵌套类的实例
class test6{

    int t6_a = 22;

    static int t6_b = 33;

    test6_qt t6_qt = new test6_qt(5);

    public void methed_t6(){
        System.out.println("我是test6类中的方法!");
    }

    static class test6_qt{

        int a;
        test6_qt(int i){
            a = i;
        }

        public void methed_qt(){
            System.out.println("我是test6的内部嵌套类的methed_qt()方法");
        }
    }


}


//使用对象作为方法的返回值
class test5{
    int a ;

    test5(int i){
        a = i;
    }

    //返回值是 test5 对象
    test5 returnBy(){
        test5 temp = new test5(a+10);

        return temp;  //将对象作为返回值值
    }
}


//使用对象作为方法参数进行传递

class test4{
    int a,b;
    //构造方法
    test4(int i,int j){
        a = i;
        b = j;
    }

    //比较对象是否相等
    boolean equals(test4 t){
        if (t.a == a && t.b ==b){
            return true;
        }else  return false;
    }
}


class test2{

    int i = 1;

    static int j = 2;

}

class test3{

    test2 t2 = new test2();

}



